/*
// src/main/java/com/yourpackage/service/QuestionService.java

package com.echo.AiManager;


import cn.hutool.json.JSONUtil;
import com.zhipu.oapi.service.v4.model.ModelData;
import io.reactivex.Flowable;
import io.reactivex.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import static com.echo.constant.AIRole.GENERATE_QUESTION_SYSTEM_MESSAGE;

@Service
public class QuestionService {
    @Autowired
    public AiManager aiManager;
    */
/**
     * 生成用于向 AI 提问的用户消息
     *
     * @param request 包含生成题目的请求信息
     * @return 格式化后的用户消息字符串
     *//*

    private String generateQuestionPrompt(AiGenerateQuestionRequest request) {
        StringBuilder userMessage = new StringBuilder();
        userMessage.append(request.getAppName()).append("\n"); // 应用名称
        userMessage.append(request.getAppDesc()).append("\n"); // 应用描述
        userMessage.append(request.getAppType()).append("类\n"); // 应用类型
        userMessage.append(request.getQuestionNumber()).append("\n"); // 题目数量
        userMessage.append(request.getOptionNumber()); // 每题选项数量
        return userMessage.toString();
    }

    */
/**
     * todo:同步调用 AI 接口生成题目
     *
     * @param aiGenerateQuestionRequest 包含请求参数的对象
     * @return 生成的题目内容列表
     *//*

    public List<QuestionContentDTO> generateQuestions(AiGenerateQuestionRequest aiGenerateQuestionRequest) {
        // 生成用户消息用于 AI 提问
        String userMessage = generateQuestionPrompt(aiGenerateQuestionRequest);

        // 调用 AI 服务，生成题目
        String result = aiManager.doSyncRequest(GENERATE_QUESTION_SYSTEM_MESSAGE, userMessage, null);

        // 提取 JSON 格式的题目信息
        int start = result.indexOf("[");
        int end = result.lastIndexOf("]");
        String json = result.substring(start, end + 1);

        // 将 JSON 转换为题目内容列表
        return JSONUtil.toList(json, QuestionContentDTO.class);
    }

    */
/**
     * 使用 SSE 异步流式生成题目
     *
     * @param aiGenerateQuestionRequest 包含请求参数的对象
     * @param scheduler 使用的线程调度器
     * @return SSEEmitter 用于向前端推送消息
     *//*

    public SseEmitter generateQuestionsSSE(AiGenerateQuestionRequest aiGenerateQuestionRequest, Scheduler scheduler) {
        // todo:1.生成用户消息用于 AI 提问
        String userMessage = generateQuestionPrompt(aiGenerateQuestionRequest);

        // 建立 SSE 连接对象
        SseEmitter sseEmitter = new SseEmitter(0L);
        AtomicInteger counter = new AtomicInteger(0);  // 左括号计数器
        StringBuilder stringBuilder = new StringBuilder();
        //todo:2.这里传过去变量【role】和信息即可，然后获得返回信息，不过因为这里是流式的，所以不一样
        // AI 流式请求，逐字符拼接题目
        Flowable<ModelData> modelDataFlowable = aiManager.doStreamRequest(GENERATE_QUESTION_SYSTEM_MESSAGE, userMessage, null);

        modelDataFlowable
                .observeOn(scheduler)
                .map(modelData -> modelData.getChoices().get(0).getDelta().getContent())
                .map(message -> message.replaceAll("\\s", ""))  // 去除空白字符
                .filter(message -> !message.isEmpty())
                .flatMap(message -> {
                    List<Character> characterList = new ArrayList<>();
                    for (char c : message.toCharArray()) {
                        characterList.add(c);
                    }
                    return Flowable.fromIterable(characterList);
                })
                .doOnNext(c -> {
                    if (c == '{') counter.incrementAndGet();  // 增加计数器
                    if (counter.get() > 0) stringBuilder.append(c);  // 拼接字符
                    if (c == '}') {
                        counter.decrementAndGet();  // 减少计数器
                        if (counter.get() == 0) {
                            // 计数器归零，发送完整的 JSON 消息
                            sseEmitter.send(JSONUtil.toJsonStr(stringBuilder.toString()));
                            stringBuilder.setLength(0);  // 清空缓冲区
                        }
                    }
                })
                .doOnError(e -> sseEmitter.completeWithError(e))  // 异常处理
                .doOnComplete(sseEmitter::complete)  // 完成时关闭 SSE
                .subscribe();

        return sseEmitter;
    }
}
*/
